package com.indusfo.spc.service.impl;

import com.indusfo.spc.exception.GlobalException;
import com.indusfo.spc.exception.ModifyFailedException;
import com.indusfo.spc.exception.ParamsErrorException;
import com.indusfo.spc.mapper.BatchScrapDetailMapper;
import com.indusfo.spc.mapper.BatchScrapMapper;
import com.indusfo.spc.pojo.BatchScrap;
import com.indusfo.spc.pojo.BatchScrapDetail;
import com.indusfo.spc.service.BatchScrapService;
import com.indusfo.spc.vo.HintMessage;
import com.indusfo.spc.vo.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

@Service
public class BatchScrapServiceImpl implements BatchScrapService {


    private  static  final Logger logger = LoggerFactory.getLogger(BatchScrapServiceImpl.class);

    @Resource
    private BatchScrapMapper batchScrapMapper;

    @Resource
    private BatchScrapDetailMapper batchScrapDetailMapper;


    /**
     * 修改
     * @param batchScrap
     * @return
     */
    @Transactional
    @Override
    public JSONObject updateBatchScrap(BatchScrap batchScrap) {
        //判空
        if(batchScrap==null){
            throw new ParamsErrorException(HintMessage.DATA_NULL);
        }
        if(batchScrap.getBatchScrapId()==null){
            throw new ParamsErrorException(HintMessage.MATFLOWID_NULL);
        }
        int i1 = batchScrapMapper.updateByPrimaryKeySelective(batchScrap);
        //获取产品报废id
        Integer batchScrapId=batchScrap.getBatchScrapId();
        //获取list集合
        List<BatchScrapDetail> newList =new ArrayList<>();
        newList = batchScrap.getBatchScrapDetailList();

        if(newList != null){
            for (BatchScrapDetail batchScrapDetail : newList ) {
                batchScrapDetail.setBatchScrapId(batchScrapId);
            }
        }
        //获取数据库数据
        BatchScrapDetail matStation1=new BatchScrapDetail();
        matStation1.setBatchScrapId(batchScrapId);
        List<BatchScrapDetail> oldList=batchScrapDetailMapper.selectAll(matStation1);
        //删除
        List<Integer> deleteList=new ArrayList<>();
        List<Integer> oldIds=new ArrayList<>();
        List<Integer> newIds=new ArrayList<>();
        if(oldList!=null) {
            for (BatchScrapDetail matStation : oldList
            ) {
                oldIds.add(matStation.getBatchId());
            }
        }
        if(newList!=null){
            for (BatchScrapDetail matStation :newList
            ) {
                newIds.add(matStation.getBatchId());
            }}
        HashSet h1 = new HashSet(oldIds);
        HashSet h2 = new HashSet(newIds);
        h1.removeAll(h2);
        deleteList.addAll(h1);
        if(deleteList.size()!=0){
            batchScrapDetailMapper.deleteBatchScrapDetail(deleteList,batchScrap.getBatchScrapId());
        }
        //删除完成  进行新增 和 修改
        if(newList!=null) {
            for (BatchScrapDetail detail : newList ) {
                if ( detail.getBatchScrapDetailId() == null) {
                    int i=0;
                   for(BatchScrapDetail oldDetail : oldList){
                       if(oldDetail.getBatchId().equals(detail.getBatchId())){
                           i=1;
                       }
                   }
                   if(i==0){
                       batchScrapDetailMapper.insertSelective(detail);
                   }
                }
            }
        }
        return JSONObject.oK(HintMessage.SAVE_SUCCESS);
    }

    /**
     * 查询
     * @param batchScrap
     * @return
     */
    @Override
    public JSONObject selectAll(BatchScrap batchScrap) {
        List<BatchScrap> listBatchScrap = null;
        try {
            Integer pagesize = batchScrap.getPagesize();
            Integer pageindex = batchScrap.getPageindex();
            if(pagesize != null && pageindex != null) {
                batchScrap.setIncept(pagesize*(pageindex - 1));
            }
            listBatchScrap = batchScrapMapper.selectAll(batchScrap);
            if (listBatchScrap.isEmpty()) {
                return JSONObject.oK("查询不到相关数据", listBatchScrap, 0);
            }
            //查询分页总记录数
            int count = batchScrapMapper.countBatchScrap(batchScrap); //返回查询到的总记录数
            return JSONObject.oK("查询成功", listBatchScrap, count);
        } catch (GlobalException e) {
            logger.error(e.getMessage(), e);
            return JSONObject.build(403, e.getMessage());
        }
    }

    /**
     * 新增
     * @param batchScrap
     * @return
     */
    @Transactional
    @Override
    public JSONObject insertBatchScrap(BatchScrap batchScrap) {
        String remark = batchScrap.getRemark();
        if(remark == null) {
            remark = "";
        }
        if(batchScrap.getBatchScrapId() != null) {
            throw new ParamsErrorException("新增时，不能填写id");
        }

        checkParam(batchScrap, remark);

        int	row = batchScrapMapper.insertSelective(batchScrap);
        Integer BatchScrapId = batchScrap.getBatchScrapId();
        Integer[] lists = batchScrap.getLists();
        if(lists.length != 0){
            //批量新增  产品报废明细
            int rows =batchScrapDetailMapper.insertBatchScrapDetailAll(lists,BatchScrapId);
        }
        if(row == 0) {
            throw new ModifyFailedException("数据新增失败");
        }
        return JSONObject.oK("新增成功");
    }


    /**
     * 停用启用删除
     * @param batchScrapIds
     * @param dataState
     * @return
     */
    @Transactional
    @Override
    public JSONObject deleteBatchScrap(Long[] batchScrapIds, Integer dataState, Integer[] auditStates) {
        if(dataState == null) {
            throw new ParamsErrorException("数据状态不能为空");
        }else if(dataState != 1 && dataState != 2 && dataState != 3) {
            throw new ParamsErrorException("数据状态错误");
        }
        if (batchScrapIds == null) {
            throw new ParamsErrorException("ID不能为空");
        }
        if (auditStates == null) {
            throw new ParamsErrorException("审核状态不能为空");
        }
        for(Integer i: auditStates){
            if(i == 2){
                throw new ParamsErrorException("已审核的无法删除");
            }
        }
        // 执行存储过程
        int row = batchScrapMapper.delteBatchScrap(batchScrapIds, dataState);
        int i = batchScrapDetailMapper.delteBatchScrapDetailByBatchScrapId(batchScrapIds, dataState);
        String msg = "";
        if (row == 0) {
            // 判断传入的数据状态参数dataState,返回相应信息
            switch (dataState) {
                case 1:
                    throw new ModifyFailedException("启用失败");
                case 2:
                    throw new ModifyFailedException("删除失败");
                case 3:
                    throw new ModifyFailedException("停用失败");
                default:
            }
        } else {
            switch (dataState) {
                case 1:
                    msg = "启用成功";break;
                case 2:
                    msg = "删除成功";break;
                case 3:
                    msg = "停用成功";break;
                default:
            }
        }
        return JSONObject.oK(msg);
    }

    @Override
    public JSONObject auditBsatchScrap(Integer[] batchScrapIds, Integer[] auditStates, Integer auditState) {
        if(auditState == null) {
            throw new ParamsErrorException("审核状态不能为空");
        }else if(auditState != 1 && auditState != 2 ) {
            throw new ParamsErrorException("审核状态错误");
        }
        if (batchScrapIds == null || batchScrapIds.length == 0) {
            throw new ParamsErrorException("ID不能为空");
        }
        if (auditStates == null || auditStates.length == 0) {
            throw new ParamsErrorException("审核状态数组不能为空");
        }
        for(Integer i : auditStates){
            if(auditState == 1){
                if(i == auditState){
                    throw new ParamsErrorException("未审核的不能反审核");
                }
            }else {
                if(i == auditState){
                    throw new ParamsErrorException("已审核的不能审核");
                }
            }
        }
        // 执行存储过程
        int row = batchScrapMapper.auditBsatchScrap(batchScrapIds, auditState);
        String msg = "";
        if (row == 0) {
            // 判断传入的审核状态参数auditState,返回相应信息
            switch (auditState) {
                case 1:
                    throw new ModifyFailedException("反审核失败");
                case 2:
                    throw new ModifyFailedException("审核失败");
                default:
            }
        } else {
            switch (auditState) {
                case 1:
                    msg = "反审核成功";break;
                case 2:
                    msg = "审核成功";break;
                default:
            }
        }
        if(auditState == 1){
            //反审核
            for (int batchScrapId: batchScrapIds) {
                BatchScrapDetail detail = new BatchScrapDetail();
                detail.setBatchScrapId(batchScrapId);
                List<BatchScrapDetail> BatchScrapDetails = batchScrapDetailMapper.selectAll(detail);
                if(BatchScrapDetails.size() != 0){
                    for (BatchScrapDetail batchScrapDetail: BatchScrapDetails) {
                        // 将批次修改回上次报废前的状态
                        int rows = batchScrapMapper.updateBatchProductStateId(batchScrapDetail);
                    }
                }
            }
        } else if(auditState == 2){
            // 审核
            for (int batchScrapId: batchScrapIds) {
                List<BatchScrapDetail> BatchScrapDetails = batchScrapDetailMapper.selectBatch(batchScrapId);
                if(BatchScrapDetails.size() != 0) {
                    for (BatchScrapDetail batchScrapDetail : BatchScrapDetails) {
                        // 修改明细中批次上次状态
                        int rows = batchScrapDetailMapper.updateByPrimaryKeySelective(batchScrapDetail);
                    }
                    // 修改批次为报废状态
                    int roess = batchScrapMapper.updateBatchProductStateIds(BatchScrapDetails);
                }
            }
        }
        return JSONObject.oK(msg);
    }


    private void checkParam(BatchScrap batchScrap, String vcRemark) {
        if (StringUtils.isEmpty(batchScrap.getBatchScrapNo())) {
            throw new ParamsErrorException("请填写产品报废编号");

        }
        if (batchScrap.getBatchScrapNo().getBytes().length > 50) {
            throw new ParamsErrorException("产品报废编号超过规定长度");
        }
        if (vcRemark.getBytes().length > 500) {
            throw new ParamsErrorException("说明字数超过规定长度");
        }
        // 名称不能重复
        Integer depCounts = batchScrapMapper.selectBatchScrap(batchScrap);
        if (depCounts !=0) {
            throw new ParamsErrorException("该产品报废编号已存在");
        }
    }
    
    
    
    
}
